home *** CD-ROM | disk | FTP | other *** search
/ Programming a Multiplayer FPS in DirectX / Programming a Multiplayer FPS in DirectX (Companion CD).iso / DirectX / dxsdk_oct2004.exe / dxsdk.exe / Utilities / MView / gxu / gxcrackfvf.h < prev    next >
Encoding:
C/C++ Source or Header  |  2004-09-30  |  15.7 KB  |  498 lines
  1. #pragma once
  2.  
  3. #ifndef __DXCRACKFVF_H__
  4. #define __DXCRACKFVF_H__
  5.  
  6. /*//////////////////////////////////////////////////////////////////////////////
  7. //
  8. // File: DXCrackFVF.h
  9. //
  10. // Copyright (C) 1999 Microsoft Corporation. All Rights Reserved.
  11. //
  12. //
  13. //////////////////////////////////////////////////////////////////////////////*/
  14.  
  15.  
  16. // -------------------------------------------------------------------------------
  17. //  class DXCrackFVF
  18. //          used to simplify retreiving and storing data to FVF formats.
  19. //          on construction, it creates a set of offsets in the FVF format
  20. //          that it uses in the the methods to access the correct members
  21. //
  22. class DXCrackFVF
  23. {
  24. public:
  25.     inline DXCrackFVF(DWORD dwFVF);
  26.  
  27.     inline PBYTE GetArrayElem(PVOID pvPoints, DWORD iElem);
  28.  
  29.     inline void         SetPosition    (PVOID pvPoint, D3DXVECTOR3 *pvPos);
  30.     inline void         SetNormal      (PVOID pvPoint, D3DXVECTOR3 *pvNormal);
  31.     inline void         SetPointSize   (PVOID pvPoint, float fPointSize);
  32.     inline void         SetDiffuse     (PVOID pvPoint, D3DCOLOR color);
  33.     inline void         SetSpecular    (PVOID pvPoint, D3DCOLOR color);
  34.     inline void         SetTex1        (PVOID pvPoint, D3DXVECTOR2 *puvTex1);
  35.  
  36.     inline void         SetTexCoord    (PVOID pvPoint, UINT iTexCoord, D3DXVECTOR2 *puvTex1);
  37.     inline void         SetTexCoord    (PVOID pvPoint, UINT iTexCoord, D3DXVECTOR3 *puvTex1);
  38.     inline void         SetTexCoord    (PVOID pvPoint, UINT iTexCoord, D3DXVECTOR4 *puvTex1);
  39.     inline void         SetTexCoord    (PVOID pvPoint, UINT iTexCoord, float *);
  40.   
  41.     inline void         SetWeight      (PVOID pvPoint, UINT iWeight,   float fWeight);
  42.     inline void         SetIndices     (PVOID pvPoint, DWORD dwIndices);
  43.  
  44.  
  45.     inline D3DXVECTOR3 *PvGetPosition    (PVOID pvPoint);
  46.     inline D3DXVECTOR3 *PvGetNormal      (PVOID pvPoint);
  47.     inline float        FGetPointSize    (PVOID pvPoint);
  48.     inline D3DCOLOR     ColorGetDiffuse  (PVOID pvPoint);
  49.     inline D3DCOLOR     ColorGetSpecular (PVOID pvPoint);
  50.     inline D3DXVECTOR2 *PuvGetTex1       (PVOID pvPoint);
  51.     inline float        *PfGetWeights     (PVOID pvPoint);
  52.     inline DWORD        DwGetIndices     (PVOID pvPoint);
  53.  
  54.     inline float       *PxGetTexCoord   (PVOID pvPoint,UINT iTexCoord);
  55.     inline D3DXVECTOR2 *PxyGetTexCoord  (PVOID pvPoint,UINT iTexCoord);
  56.     inline D3DXVECTOR3 *PxyzGetTexCoord (PVOID pvPoint,UINT iTexCoord);
  57.     inline D3DXVECTOR4 *PxyzwGetTexCoord(PVOID pvPoint,UINT iTexCoord);
  58.  
  59.     inline float        FGetWeight     (PVOID pvPoint, UINT iWeight);
  60.  
  61.     inline bool         BPosition()     { return true; }
  62.     inline bool         BNormal()       { return m_oNormal > 0; }
  63.     inline bool         BPointSize()    { return m_oPointSize > 0; }
  64.     inline bool         BDiffuse()      { return m_oDiffuse > 0; }
  65.     inline bool         BSpecular()     { return m_oSpecular > 0; }
  66.     inline bool         BTex1()         { return m_oTex[0] > 0; }
  67.  
  68.     inline DWORD        CWeights()      { return m_cWeights; }
  69.     inline DWORD        CTexCoords()    { return m_cTexCoords; }
  70.     inline DWORD        CbTexCoordSize(DWORD iTexCoord);
  71.     inline void         GetTexCoordSizes(DWORD *rgdwTexCoordSizes);
  72.  
  73.     inline BOOL         BIndexedWeights() { return (m_dwFVF & D3DFVF_LASTBETA_UBYTE4|D3DFVF_LASTBETA_D3DCOLOR) && m_cWeights; }
  74.  
  75.  
  76.     DWORD m_dwFVF;
  77.     DWORD m_cBytesPerVertex; 
  78.     DWORD m_oNormal;
  79.     DWORD m_oPointSize;
  80.     DWORD m_oDiffuse;
  81.     DWORD m_oSpecular;
  82.     DWORD m_oTex[8];
  83.     DWORD m_cWeights;
  84.     DWORD m_cTexCoords;
  85. };
  86.  
  87.  
  88. // -------------------------------------------------------------------------------
  89. //  class DXCrackFVF inline functions - used to simplify access to the FVF 
  90. //
  91.  
  92. const DWORD x_rgdwTexCoordSize[] = { 2 * sizeof(float), 3 * sizeof(float), 4 * sizeof(float), sizeof(float)};
  93.  
  94. // -------------------------------------------------------------------------------
  95. //  constructor for DXCrackFVF, generates offsets used to access members
  96. //      of the given FVF
  97. //
  98. inline 
  99. DXCrackFVF::DXCrackFVF(DWORD dwFVF)
  100. :m_dwFVF(dwFVF),
  101. m_oNormal(0),
  102. m_oPointSize(0),
  103. m_oDiffuse(0),
  104. m_oSpecular(0),
  105. m_cWeights(0),
  106. m_cTexCoords(0)
  107. {
  108.     DWORD oCur = 0;
  109.     DWORD dwPosition;
  110.     DWORD dwTexCoordInfo;
  111.     DWORD iTexCoord;
  112.     DWORD dwTexCoordSize;
  113.     m_oTex[0] = 0;
  114.  
  115.     dwPosition = dwFVF & D3DFVF_POSITION_MASK;
  116.  
  117.     if (dwPosition == D3DFVF_XYZ)
  118.     {
  119.         oCur += 3 * sizeof(float);
  120.     }
  121.     else if (dwPosition == D3DFVF_XYZRHW)
  122.     {
  123.         oCur += 4 * sizeof(float);
  124.     }
  125.     else if (dwPosition >= D3DFVF_XYZB1)
  126.     {
  127.         m_cWeights = (dwPosition >> 1) - 2;
  128.         oCur += (3 + m_cWeights) * sizeof(float);
  129.     }
  130.  
  131.     if ( dwFVF & D3DFVF_NORMAL )
  132.     {
  133.         m_oNormal = oCur;
  134.         oCur += 3 * sizeof(float);
  135.     }
  136.  
  137.     if ( dwFVF & D3DFVF_PSIZE )
  138.     {
  139.         m_oPointSize = oCur;
  140.         oCur += sizeof(float);
  141.     }
  142.  
  143.     if ( dwFVF & D3DFVF_DIFFUSE )
  144.     {
  145.         m_oDiffuse = oCur;
  146.         oCur += sizeof(D3DCOLOR);
  147.     }
  148.  
  149.     if ( dwFVF & D3DFVF_SPECULAR )
  150.     {
  151.         m_oSpecular = oCur;
  152.         oCur += sizeof(D3DCOLOR);
  153.     }
  154.  
  155.     if ( dwFVF & D3DFVF_TEXCOUNT_MASK )
  156.     {
  157.         m_oTex[0] = oCur;
  158.  
  159.         // only one tu/tv set currently supported
  160.  
  161.         m_cTexCoords = ((dwFVF & D3DFVF_TEXCOUNT_MASK)>>D3DFVF_TEXCOUNT_SHIFT);
  162.  
  163.         if(m_cTexCoords > 8)
  164.             m_cTexCoords = 8;
  165.  
  166.         // all 2d, then go quick route
  167.         //if ((dwFVF & 0xffff0000) == 0)
  168.         //{
  169.             //oCur += sizeof(float) * 2 * m_cTexCoords;
  170.         //}
  171.         //else
  172.         {
  173.             dwTexCoordSize = (dwFVF & 0xffff0000) >> 16;
  174.             for (iTexCoord = 0; iTexCoord < m_cTexCoords; iTexCoord++)
  175.             {
  176.                 m_oTex[iTexCoord] = oCur;
  177.                 oCur += x_rgdwTexCoordSize[dwTexCoordSize & 0x3];
  178.                 dwTexCoordSize = dwTexCoordSize >> 2;
  179.             }
  180.         }
  181.     }
  182.  
  183.     m_cBytesPerVertex = oCur;
  184. }
  185.  
  186.  
  187. // -------------------------------------------------------------------------------
  188. //  function - GetArrayElem,  gets the ith element of the given FVF array
  189. //
  190. inline PBYTE 
  191. DXCrackFVF::GetArrayElem(PVOID pvPoints, DWORD iElem)
  192. { 
  193.     return ((PBYTE)pvPoints + (iElem * m_cBytesPerVertex)); 
  194. }
  195.  
  196. // -------------------------------------------------------------------------------
  197. //  function - SetPosition, sets the given position into the given FVF point
  198. //
  199. inline void 
  200. DXCrackFVF::SetPosition    (PVOID pvPoint, D3DXVECTOR3 *pvPos)
  201. {
  202.     memcpy(pvPoint, pvPos, sizeof(D3DXVECTOR3));
  203. }
  204.  
  205. // -------------------------------------------------------------------------------
  206. //  function - SetNormal, sets the given normal into the given FVF point
  207. //                  if no normal, this call is a no-op
  208. //
  209. inline void 
  210. DXCrackFVF::SetNormal      (PVOID pvPoint, D3DXVECTOR3 *pvNormal)
  211. {
  212.     if (m_oNormal)
  213.     {
  214.         memcpy(((PBYTE)pvPoint) + m_oNormal, pvNormal, sizeof(D3DXVECTOR3));
  215.     }
  216. }
  217.  
  218. // -------------------------------------------------------------------------------
  219. //  function - SetPointsize, sets the given point size into the given FVF point
  220. //                  if no normal, this call is a no-op
  221. //
  222. inline void 
  223. DXCrackFVF::SetPointSize   (PVOID pvPoint, float fPointSize)
  224. {
  225.     if (m_oPointSize)
  226.     {
  227.         memcpy(((PBYTE)pvPoint) + m_oPointSize, &fPointSize, sizeof(float));
  228.     }
  229. }
  230.  
  231. // -------------------------------------------------------------------------------
  232. //  function - SetDiffuse, sets the given diffuse color into the given FVF point
  233. //                  if no diffuse color, this call is a no-op
  234. //
  235. inline void 
  236. DXCrackFVF::SetDiffuse     (PVOID pvPoint, D3DCOLOR color)
  237. {
  238.     if (m_oDiffuse)
  239.     {
  240.         memcpy(((PBYTE)pvPoint) + m_oDiffuse, &color, sizeof(D3DCOLOR));
  241.     }
  242. }
  243.  
  244. // -------------------------------------------------------------------------------
  245. //  function - SetSpecular, sets the given specular color into the given FVF point
  246. //                  if no specular color, this call is a no-op
  247. //
  248. inline void 
  249. DXCrackFVF::SetSpecular    (PVOID pvPoint, D3DCOLOR color)
  250. {
  251.     if (m_oSpecular)
  252.     {
  253.         memcpy(((PBYTE)pvPoint) + m_oSpecular, &color, sizeof(D3DCOLOR));
  254.     }
  255. }
  256.  
  257. // -------------------------------------------------------------------------------
  258. //  function - SetTex1, sets the given Tex1 UV coords into the given FVF point
  259. //                  if no Tex1 coords, this call is a no-op
  260. //
  261. inline void 
  262. DXCrackFVF::SetTex1        (PVOID pvPoint, D3DXVECTOR2 *puvTex1)
  263. {
  264.     if (m_oTex[0])
  265.     {
  266.         memcpy(((PBYTE)pvPoint) + m_oTex[0], puvTex1, sizeof(D3DXVECTOR2));
  267.     }
  268. }
  269.  
  270.  
  271. //above function is skecthy, won't work for variable size textore coordinates, replaced
  272. //with following family
  273. inline void 
  274. DXCrackFVF::SetTexCoord    (PVOID pvPoint, UINT iTexCoord, D3DXVECTOR2 *pvTexCoord)
  275. {
  276.     if (iTexCoord < m_cTexCoords)
  277.     {
  278.         memcpy(((PBYTE)pvPoint) + m_oTex[iTexCoord], pvTexCoord, sizeof(D3DXVECTOR2));
  279.     }
  280. }
  281.  
  282. inline void 
  283. DXCrackFVF::SetTexCoord    (PVOID pvPoint, UINT iTexCoord, D3DXVECTOR3 *pvTexCoord)
  284. {
  285.     if (iTexCoord < m_cTexCoords)
  286.     {
  287.         memcpy(((PBYTE)pvPoint) + m_oTex[iTexCoord], pvTexCoord, sizeof(D3DXVECTOR3));
  288.     }
  289. }
  290.  
  291. inline void 
  292. DXCrackFVF::SetTexCoord    (PVOID pvPoint, UINT iTexCoord, D3DXVECTOR4 *pvTexCoord)
  293. {
  294.     if (iTexCoord < m_cTexCoords)
  295.     {
  296.         memcpy(((PBYTE)pvPoint) + m_oTex[iTexCoord], pvTexCoord, sizeof(D3DXVECTOR4));
  297.     }
  298. }
  299.  
  300. inline void 
  301. DXCrackFVF::SetTexCoord(PVOID pvPoint, UINT iTexCoord, float *pvTexCoord)
  302. {
  303.     if (iTexCoord < m_cTexCoords)
  304.     {
  305.         memcpy(((PBYTE)pvPoint) + m_oTex[iTexCoord], pvTexCoord, sizeof(float));
  306.     }
  307. }
  308.  
  309.  
  310.  
  311.  
  312. // -------------------------------------------------------------------------------
  313.  
  314. //  function - SetWeight, sets the given blend weight into the given FVF point
  315. //                  if the specified blend weight is not present, just return
  316. //
  317. inline void 
  318. DXCrackFVF::SetWeight     (PVOID pvPoint, UINT iWeight, float fWeight)
  319. {
  320.     if (iWeight < m_cWeights)
  321.     {
  322.         memcpy(((PBYTE)pvPoint) + sizeof(D3DXVECTOR3) + sizeof(float) * iWeight, &fWeight, sizeof(float));
  323.     }
  324. }
  325.  
  326. // -------------------------------------------------------------------------------
  327.  
  328. //  function - SetWeight, sets the given blend weight into the given FVF point
  329. //                  if the specified blend weight is not present, just return
  330. //
  331. inline float
  332. DXCrackFVF::FGetWeight     (PVOID pvPoint, UINT iWeight)
  333. {
  334.     return *(float*)(((PBYTE)pvPoint) + sizeof(D3DXVECTOR3) + sizeof(float) * iWeight);
  335. }
  336.  
  337. // -------------------------------------------------------------------------------
  338. //  function - SetIndices, sets the given indices into the given FVF point
  339. //                  if no indices, this call is a no-op
  340. //
  341. inline void
  342. DXCrackFVF::SetIndices    (PVOID pvPoint, DWORD dwIndices)
  343. {
  344.     if (BIndexedWeights())
  345.     {
  346.         *((LPDWORD)(((PBYTE)pvPoint) + sizeof(D3DXVECTOR3) + sizeof(float) * (CWeights() - 1))) = dwIndices;
  347.     }
  348. }
  349.  
  350. // -------------------------------------------------------------------------------
  351. //  function - PvGetPosition, returns a pointer to the position in the given FVF vertex
  352. //
  353. inline D3DXVECTOR3  *
  354. DXCrackFVF::PvGetPosition    (PVOID pvPoint)
  355. {
  356.     return (D3DXVECTOR3*)pvPoint;
  357. }
  358.  
  359. // -------------------------------------------------------------------------------
  360. //  function - PvGetNormal, returns a pointer to the normal in the given FVF vertex
  361. //                              NOTE: the normal HAS to be present in the FVF format
  362. //
  363. inline D3DXVECTOR3 *
  364. DXCrackFVF::PvGetNormal      (PVOID pvPoint)
  365. {
  366.     return (D3DXVECTOR3*)  (((PBYTE)pvPoint) + m_oNormal);
  367. }
  368.  
  369. // -------------------------------------------------------------------------------
  370. //  function - FGetPointSize, returns a the pointsize in the given FVF vertex
  371. //                              NOTE: the point size HAS to be present in the FVF format
  372. //
  373. inline float
  374. DXCrackFVF::FGetPointSize    (PVOID pvPoint)
  375. {
  376.     return *( (float*)  (((PBYTE)pvPoint) + m_oPointSize) );
  377. }
  378.  
  379. // -------------------------------------------------------------------------------
  380. //  function - ColorGetDiffuse, returns the diffuse color in the given FVF vertex
  381. //                              NOTE: the color HAS to be present in the FVF format
  382. //
  383. inline D3DCOLOR  
  384. DXCrackFVF::ColorGetDiffuse  (PVOID pvPoint)
  385. {
  386.     return *(D3DCOLOR*)  (((PBYTE)pvPoint) + m_oDiffuse);
  387. }
  388.  
  389. // -------------------------------------------------------------------------------
  390. //  function - ColorGetSpecular, returns the specular color in the given FVF vertex
  391. //                              NOTE: the color HAS to be present in the FVF format
  392. //
  393. inline D3DCOLOR  
  394. DXCrackFVF::ColorGetSpecular (PVOID pvPoint)
  395. {
  396.     return *(D3DCOLOR*)  (((PBYTE)pvPoint) + m_oSpecular);
  397. }
  398.  
  399. // -------------------------------------------------------------------------------
  400. //  function - PuvGetTex1, returns a pointer to the tex1 position in the given FVF vertex
  401. //                              NOTE: the tex1 HAS to be present in the FVF format
  402. //
  403. inline D3DXVECTOR2  *
  404. DXCrackFVF::PuvGetTex1       (PVOID pvPoint)
  405. {
  406.     return (D3DXVECTOR2*)  (((PBYTE)pvPoint) + m_oTex[0]);
  407. }
  408.  
  409.  
  410.  
  411. //family of functions that cast the texture stage to a D3DXVector
  412. //of the right size
  413.  
  414. inline float*
  415. DXCrackFVF::PxGetTexCoord(PVOID pvPoint,UINT index)
  416. {
  417.     return (float*) (((PBYTE)pvPoint) + m_oTex[index]);
  418. }
  419.  
  420. inline D3DXVECTOR2  *
  421. DXCrackFVF::PxyGetTexCoord(PVOID pvPoint,UINT index)
  422. {
  423.     return (D3DXVECTOR2*) (((PBYTE)pvPoint) + m_oTex[index]);
  424. }
  425.  
  426.  
  427. inline D3DXVECTOR3  *
  428. DXCrackFVF::PxyzGetTexCoord(PVOID pvPoint,UINT index)
  429. {
  430.     return (D3DXVECTOR3*) (((PBYTE)pvPoint) + m_oTex[index]);
  431. }
  432.  
  433.  
  434. inline D3DXVECTOR4  *
  435. DXCrackFVF::PxyzwGetTexCoord(PVOID pvPoint,UINT index)
  436. {
  437.     return (D3DXVECTOR4*) (((PBYTE)pvPoint) + m_oTex[index]);
  438. }
  439. // -------------------------------------------------------------------------------
  440. //  function - PuvGetWeights, returns a pointer to the first weight 
  441. //                              NOTE: the weights HAS to be present in the FVF format
  442. //
  443. inline float  *
  444. DXCrackFVF::PfGetWeights       (PVOID pvPoint)
  445. {
  446.     return (float*)(((PBYTE)pvPoint) + sizeof(D3DXVECTOR3));
  447. }
  448.  
  449. // -------------------------------------------------------------------------------
  450. //  function - CbTexCoordSize, returns the size of the given set of texture coordinates
  451. //
  452. inline DWORD
  453. DXCrackFVF::CbTexCoordSize       (DWORD iTexCoord)
  454. {
  455.     if (iTexCoord < m_cTexCoords)
  456.         return x_rgdwTexCoordSize[(m_dwFVF >> (16 + iTexCoord * 2)) & 0x3];
  457.     else
  458.         return 0;
  459. }
  460.  
  461. // -------------------------------------------------------------------------------
  462. //  function - CbTexCoordSize, returns the sizes of all 8 texture coords (0 if not present)
  463. //
  464. inline void
  465. DXCrackFVF::GetTexCoordSizes       (DWORD *rgdwTexCoordSizes)
  466. {
  467.     DWORD iTexCoord;
  468.  
  469.     for (iTexCoord = 0; iTexCoord < m_cTexCoords; iTexCoord++)
  470.     {
  471.        
  472.         rgdwTexCoordSizes[iTexCoord] = x_rgdwTexCoordSize[(m_dwFVF >> (16 + iTexCoord * 2)) & 0x3];
  473.  
  474.  
  475.     }
  476.  
  477.     // set the rest to 0
  478.     for (;iTexCoord < 8; iTexCoord++)
  479.     {
  480.         rgdwTexCoordSizes[iTexCoord] = 0;
  481.     }
  482. }
  483.  
  484.  
  485.     inline void         GetTexCoordSizes(DWORD *rgdwTexCoordSizes);
  486.  
  487. // -------------------------------------------------------------------------------
  488. //  function - DwGetIndices, returns the indices in the given FVF vertex
  489. //                              NOTE: the indices HAS to be present in the FVF format
  490. //
  491. inline DWORD
  492. DXCrackFVF::DwGetIndices    (PVOID pvPoint)
  493. {
  494.     return *( (DWORD*)  (((PBYTE)pvPoint) + sizeof(D3DXVECTOR3) + sizeof(float) * (CWeights() - 1)) );
  495. }
  496.  
  497. #endif //__DXCRACKFVF_H__
  498.